# 1、输入数字n，输出n天前的日期（time或者datatime模块）
# 2、输出指定文件夹下有哪些文件或文件夹（实现ls命令， os）
# 3、列表去重，并且从小到大排序
# 4、如何在一个函数内部修改全局变量
# 5、如何跨模块共享全局变量
# 6、python的基本数据类型有哪些？
# 7、python中生成随机整数（1-10），随机小数（1-10），随机小数（0-1）的方法
# 8、python中哪些是可变数据类型，哪些是不可变数据类型
# 9、a+=1与a=a+1有什么区别
# 10、什么是pep8？说出5点它的标准
# 11、给定一个字符串，找出字符串第一个重复的字符
# 12、简述深拷贝与浅拷贝
# 13、简述python内存机制
# 14、使用python实现冒泡排序，快速排序
# 15、验证一个字符串是否属于回文（从左到右，从右到左都是一样）


# 1、输入数字n，输出n天前的日期（time或者datatime模块）
# datetime模块
# object
#     timedelta
#     tzinfo
#         timezone
#     time
#     date
#         datetime
from cmath import pi
from operator import index
from turtle import end_fill, pos
def ex1(n):
    import datetime
    date = datetime.date
    today = date.today()
    interval = datetime.timedelta(days=n)
    return today - interval
# print(ex1(1000))


# 2、输出指定文件夹下有哪些文件或文件夹（实现ls命令， os）
# os.path模块
# os.path.getatime(path)
# os.path.getmtime(path)
# os.path.getctime(path)
# os.path.getsize(path)
# os.listdir(path)
def ex2(path):
    import os
    if os.path.exists(path):
        for i in os.listdir(path):
            # abs_path = os.path.join(path, i)
            print(i)
    else:
        print('文件不存在')

# while True:
#     path = input("please input a path(or 'exit'):")
#     if path == 'exit':
#         break
#     else:
#         ex2(path)



# 3 列表去重
def ex3(lst):
    lst = list(set(lst))
    lst.sort()
    return lst
# print(ex3([1,2,2,1,3,5,6,9,6,7,4,56,3]))


# 5、如何跨模块共享全局变量
# import sharevar
# print(sharevar.money)
# sharevar.money -= 100
# print(sharevar.money)

# 6、python的基本数据类型有哪些？
# 整形、浮点性、复数、字符串、列表、元组、字典、集合


# 4 修改全局变量
var = 100
def ex4():
    global var
    var = 50
# ex4()
# print(var)

# 7 python中生成随机整数（1-10），随机小数（1-10），随机小数（0-1）的方法
def ex7():
    import random
    rint = random.randint(1,10)
    rfloat = random.random()*10
    mrfloat = random.random()
    print(f"随机整数（1-10）:{rint}  随机小数（1-10）:{rfloat}  随机小数（0-1）:{mrfloat}")
# ex7()
        

# 8、python中哪些是可变数据类型，哪些是不可变数据类型
# 可变数据类型：列表、字典、集合
# 不可变数据类型：整形、浮点性、复数、字符串、元组


# 9、a+=1与a=a+1有什么区别
# 对于不可变数据类型没区别
def ex9():
    a = 1
    b = 2
    for i in range(10):
        print(f"a value:{a} id:{hex(id(a))}", end='    ')
        print(f"b value:{b} id:{hex(id(b))}")
        a += 1
        b = b + 1
# ex9()

# 10、什么是pep8？说出5点它的标准
# 参考https://wenku.baidu.com/view/7f4c20491db91a37f111f18583d049649b660e62.html
# pep8 == 编码规范
# 缩进
# 不要使⽤ tab 缩进
# 使⽤任何编辑器写 Python，请把⼀个 tab 展开为 4 个空格
# 绝对不要混⽤ tab 和空格，否则容易出现 IndentationErro
# 空格
# 在 list, dict, tuple, set, 参数列表的 , 后⾯加⼀个空格
# 在 dict 的 : 后⾯加⼀个空格
# 在注释符号 # 后⾯加⼀个空格，但是 #!/usr/bin/python 的 # 后不能有空格
# 操作符两端加⼀个空格，如 +, -, *, /, |, &, =
# 接上⼀条，在参数列表⾥的 = 两端不需要空格
# 括号（(), {}, []）内的两端不需要空格
# 空⾏
# function 和 class 顶上两个空⾏
# class 的 method 之间⼀个空⾏
# 函数内逻辑⽆关的段落之间空⼀⾏，不要过度使⽤空⾏
# 不要把多个语句写在⼀⾏，然后⽤ ; 隔开
# if/for/while 语句中，即使执⾏语句只有⼀句，也要另起⼀⾏
# 换⾏
# 每⼀⾏代码控制在 80 字符以内
# 使⽤ \ 或 () 控制换⾏，举例：
# 空格
# 在 list, dict, tuple, set, 参数列表的 , 后⾯加⼀个空格
# 在 dict 的 : 后⾯加⼀个空格
# 在注释符号 # 后⾯加⼀个空格，但是 #!/usr/bin/python 的 # 后不能有空格
# 操作符两端加⼀个空格，如 +, -, *, /, |, &, =
# 接上⼀条，在参数列表⾥的 = 两端不需要空格
# 括号（(), {}, []）内的两端不需要空格
# 空⾏
# function 和 class 顶上两个空⾏
# class 的 method 之间⼀个空⾏
# 函数内逻辑⽆关的段落之间空⼀⾏，不要过度使⽤空⾏
# 不要把多个语句写在⼀⾏，然后⽤ ; 隔开
# if/for/while 语句中，即使执⾏语句只有⼀句，也要另起⼀⾏
# 换⾏
# 每⼀⾏代码控制在 80 字符以内
# 使⽤ \ 或 () 控制换⾏，举例：
# 空格
# 在 list, dict, tuple, set, 参数列表的 , 后⾯加⼀个空格
# 在 dict 的 : 后⾯加⼀个空格
# 在注释符号 # 后⾯加⼀个空格，但是 #!/usr/bin/python 的 # 后不能有空格
# 操作符两端加⼀个空格，如 +, -, *, /, |, &, =
# 接上⼀条，在参数列表⾥的 = 两端不需要空格
# 括号（(), {}, []）内的两端不需要空格
# 空⾏
# function 和 class 顶上两个空⾏
# class 的 method 之间⼀个空⾏
# 函数内逻辑⽆关的段落之间空⼀⾏，不要过度使⽤空⾏
# 不要把多个语句写在⼀⾏，然后⽤ ; 隔开
# if/for/while 语句中，即使执⾏语句只有⼀句，也要另起⼀⾏
# 换⾏
# 每⼀⾏代码控制在 80 字符以内
# 使⽤ \ 或 () 控制换⾏，举例：



# 11、给定一个字符串，找出字符串第一个重复的字符
def ex11(str1):
    char_lst = []
    for i in str1:
        if i in char_lst:
            print(i)
        else:
            char_lst.append(i)
# ex11('abcadil')
    
    
# 12、简述深拷贝与浅拷贝
# 对于可变数据类型嵌套可变数据类型时，有深拷贝和浅拷贝的区别
# lst1 = [1, 2, 3, 4, 5, [1, 2, 3]]
# 浅拷贝拷贝的是外层可变数据类型中的每一项数据的地址，
# lst2 = lst1.copy()
# 深拷贝，如果可变数据类型中有可变数据类型，会一直拷贝到最里层的数据地址
# import copy
# lst3 = copy.deepcopy(lst1)
# 13、简述python内存机制



# 14、使用python实现冒泡排序，快速排序
def ex14_maopao(lst):
    for i in range(1, len(lst)):
        min_index = i-1
        # for index, j in enumerate(lst[i:]):
        #     if j < lst[min_index]:
        #         min_index = index+i
        for j in range(i, len(lst)):
            if lst[j] < lst[min_index]:
                min_index = j
        lst[min_index], lst[i-1] = lst[i-1], lst[min_index]
lst = [3, 5, 2, 5, 9, 10, 44, 33, 42, 43, 34]
# ex14_maopao(lst)
# print(lst)

# 递归双指针实现
def ex14_fast(lst, start, last):
    pre_index = start
    post_index = last
    temp = lst[pre_index]
    while(pre_index < post_index):
        # if lst[pre_index] > lst[post_index]:
        #     lst[pre_index], lst[post_index] = lst[post_index], lst[pre_index]
        #     pre_index += 1
        # else:
        #     post_index -= 1
        while(pre_index<post_index and temp <= lst[post_index]):
            post_index -= 1
        lst[pre_index] = lst[post_index]
        while(pre_index<post_index and lst[pre_index] <= temp):
            pre_index += 1
        lst[post_index] = lst[pre_index]
    lst[post_index] = temp
    start<post_index-1 and ex14_fast(lst, start, post_index-1)
    pre_index+1<last and ex14_fast(lst, pre_index+1, last)    

# ex14_fast(lst, 0, len(lst)-1 )
# print(lst)

# 非递归实现
import random
def ex14_fast2(lst):
    scope = {}
    scope[0] = len(lst)-1
    while(scope):
        start, end = scope.popitem()
        pivot = random.randint(start, end)
        lst[start], lst[pivot] = lst[pivot], lst[start]
        pivot = start
        index = start + 1
        i = index
        while(i <= end):
            if lst[i] < lst[pivot]:
                lst[index], lst[i] = lst[i], lst[index]
                index += 1
            i += 1
        lst[pivot], lst[index-1] = lst[index-1], lst[pivot]
        if start < index-2:
            scope[start] = index -2
        if index < end:
            scope[index] = end
ex14_fast2(lst)
print(lst)

# 分步实现
def partition(lst, left, right):
    pivot = random.randint(left, right)
    lst[left], lst[pivot] = lst[pivot], lst[left]
    pivot = left
    index = left + 1
    i = index
    while(i <= right):
        if lst[i] < lst[pivot]:
            lst[i], lst[index] = lst[index], lst[i]
            index += 1
        i += 1
    lst[index-1], lst[pivot] = lst[pivot], lst[index-1]
    return index - 1
    
def quickSort(lst, start, end):
    scope = {}
    scope[start] = end
    while scope:
        i, j = scope.popitem()
        pivot = partition(lst, i, j)
        if i<pivot-1:
            scope[i] = pivot - 1
        if pivot+1<j:
            scope[pivot+1] = j
# quickSort(lst, 0, len(lst)-1)
# print(lst)

# 15、验证一个字符串是否属于回文（从左到右，从右到左都是一样）
def ex15(one_str):
    str1 = one_str[::-1]
    if str1 == one_str:
        print('是回文')
    else:
        print('不是回文')
# ex15('abcdefg')
# ex15('abcdcba')



